// Livestock - 牲畜
#include <string>
#include <vector>
#include <fstream>
#include <iostream>
#include <algorithm>

using namespace std;

// 用 Livestock 表达算法
class Livestock {
public:
  // 1. 参与挤奶的奶牛的名字
  vector<string> cows;

  // 2. 有哪些 X 牛
  vector<string> xCows;
  
  // 3. 有哪些 Y 牛
  vector<string> yCows;
  // xCows[i] 必须和 yCows[i] 挨在一起挤奶

  // 4. 有多少条需要满足的规则
  int rules;

  // 5. 满足所有挤奶规则的奶牛名称顺序：答案
  vector<string> answer;

public:
  // 定义构造函数
  Livestock(const string &inputFilename) {
    ifstream ifs(inputFilename);

    // 按照属性定义的顺序，来初始化它们。
    cows = {
      "Bessie", "Buttercup", "Belinda", "Beatrice", "Bella", "Blue", "Betsy", "Sue"
    };

    // 初始化 xCows / yCows / rules
    // 读取 ifs 来设置
    ifs >> rules;

    for (int i = 0; i < rules; ++i) {
      // X must be milked beside Y
      string xCow;
      string yCow;
      string rubbish;
      ifs >> xCow;

      ifs >> rubbish; // must
      ifs >> rubbish; // be
      ifs >> rubbish; // milked
      ifs >> rubbish; // beside

      ifs >> yCow;

      xCows.push_back(xCow);
      yCows.push_back(yCow);
    }

    answer = {};
  }

  // 判断 name 是否在 answer 数组里，如果在就返回在 answer 中的数字位置，
  // 否则，就返回 -1。
  int getIndex(const string &name) {
    for (int i = 0; i < answer.size(); ++i) {
      return i;
    }

    return -1;
  }

  // 判定名称为 name 的奶牛是否可以放到 answer 数组里，
  // 如果能，返回 true，否则，就返回 false。
  bool canBePickedUp(const string &name) {
    // 挑选出所有不能放入 answer 的情况 return false;
    // 1. name 已经在 answer 里了？
    if (getIndex(name) != -1) {
      return false;
    }

    // 2. 如果 name 有两个不在 answer 里的邻居，那么不能直接放入 name。
    // 把挨着挤奶的牛叫做邻居。
    /*
    Buttercup must be milked beside Bella
    Blue must be milked beside Bella
    Sue must be milked beside Beatrice

    Buttercup Bella Blue
    Blue Bella Buttercup
    */
    int nbrs = 0; // name 的邻居的个数
    // 遍历 cows，检查每一个牛的名字，确定它是否是不在 answer 里的邻居
    for (int i = 0; i < rules; ++i) {
      // xCows 的情况
      if (xCows[i] == name && getIndex(yCows[i]) == -1) {
        ++nbrs;
      }
      // yCows 的情况
      if (yCows[i] == name && getIndex(xCows[i]) == -1) {
        ++nbrs;
      }
    }

    if (nbrs == 2) {
      return false;
    }

    // 最后一种不能把 name 放入到 answer 的情况
    if (!answer.empty()) {
      for (int i = 0; i < rules; ++i) {
        if (answer.back() == xCows[i] && getIndex(yCows[i]) == -1 && yCows[i] != name) {
          return false;
        }

        if (answer.back() == yCows[i] && getIndex(xCows[i]) == -1 && xCows[i] != name) {
          return false;
        }
      }
    }

    // 所有不在上面这些情况里的，return true;
    // 没有邻居的 name
    // 只有一个邻居的 name，并且，它的邻居是 answer 的最后一个元素
    return true;
  }

  // 求解答案
  void solution() {
    // 计算 answer
    // "Bessie", "Buttercup", "Belinda", "Beatrice", "Bella", "Blue", "Betsy", "Sue"
    // 遍历 8 次 cows 数组：
    //   从中找到一个可以放入到 answer 中的名字: canBePickedUp
    //   更新 answer
    //   开始下一次循环
    
  }
};

int main(int argc, char const *argv[])
{
  /* code */
  Livestock problem("lineup.in");
  problem.solution(); // 求解算法

  for (string name : problem.answer) {
    cout << name << endl;
  }

  return 0;
}
